#include "mainwindow.h"
#include "obstacle.h"
#include "coin.h"
#include "powerup.h"
#include "characterselectdialog.h"
#include "characterselectdialog.h"
#include <QApplication>
#include <QCloseEvent>
#include <QGraphicsView>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QMessageBox>
#include <QPushButton>
#include <QRandomGenerator>
#include <QFile>
#include <math.h>
#include <QAbstractAnimation>
#include <QGraphicsOpacityEffect>
// 构造函数与析构函数
MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , player(nullptr)

{
    // 窗口基础设置
    setWindowFlags(Qt::Window);
    setFixedSize(VIEW_WIDTH, VIEW_HEIGHT);

    // 初始化核心组件
    setupScene();// 场景初始化
    initializeTimers();// 定时器系统
    setupAudioSystem();// 音频系统

}

MainWindow::~MainWindow()
{
    gameTimer->stop();
    coinTimer->stop();
    powerupTimer->stop();
    disconnect(achievementManager.data(), nullptr, this, nullptr);
}
// 场景初始化
void MainWindow::setupScene()
{
    // 创建场景和视图
    scene = new QGraphicsScene(this);
    view = new QGraphicsView(scene, this);

    // 视图配置
    view->setFixedSize(VIEW_WIDTH, VIEW_HEIGHT);//固定视图尺寸
    view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);//禁用滚动条
    view->setSceneRect(0, 0, VIEW_WIDTH, VIEW_HEIGHT);//设置视图的显示区域
    view->setAlignment(Qt::AlignLeft | Qt::AlignTop);//将场景内容固定在视图的左上角对齐

    // 背景轮播项初始化
    for (int i = 0; i < 12; ++i) {
        QString path = QString(":/bg%1.png").arg(i + 1);//%1 是占位符，通过 .arg(i+1) 将其替换为循环变量 i+1 的值
        QPixmap pixmap(path);
        pixmap = pixmap.scaled(VIEW_WIDTH, VIEW_HEIGHT,
                               Qt::KeepAspectRatio, Qt::SmoothTransformation);//​图片适配显示尺寸
        QGraphicsPixmapItem* item = new QGraphicsPixmapItem(pixmap);
        item->setPos(i * VIEW_WIDTH, (VIEW_HEIGHT - pixmap.height()) / 2);//​创建图形项并定位
        item->setData(0, i);
        scene->addItem(item);
        m_slideItems.append(item);// ​添加至场景和列表
    }


    scoreText = new QGraphicsTextItem("得分: 0"); //​创建得分文本项
    scoreText->setDefaultTextColor(Qt::black);// 设置文本颜色为黑色
    scoreText->setFont(QFont("Arial", 20, QFont::Bold));// 设置字体为Arial、20号、加粗
    scoreText->setPos(20, 20);// 设置文本项在场景坐标系中的位置
    scene->addItem(scoreText);// 将文本项添加到场景中


}

// 定时器系统
void MainWindow::initializeTimers()
{

    gameTimer = new QTimer(this);     // 游戏主循环定时器（约60FPS）
    coinTimer = new QTimer(this);    // 金币生成定时器
    powerupTimer = new QTimer(this); // 道具生成定时器
    hoverTimer = new QTimer(this);   // 悬浮状态持续时间控制器
    m_slideTimer = new QTimer(this); // 背景滚动定时器


    // 立即启动背景滚动定时器，16ms间隔对应约60FPS的流畅动画
    m_slideTimer->start(16);

    // 连接定时器信号与对应槽函数
    connect(gameTimer, &QTimer::timeout, this, &MainWindow::updateGame);    // 主游戏循环
    connect(coinTimer, &QTimer::timeout, this, &MainWindow::generateCoin);  // 定期生成金币
    connect(powerupTimer, &QTimer::timeout, this, &MainWindow::generatePowerUp); // 生成道具
    connect(m_slideTimer, &QTimer::timeout, this, &MainWindow::updateSlides); // 背景滚动更新

    // 悬浮状态结束时的复位处理
    connect(hoverTimer, &QTimer::timeout, [this]() {//Lambda表达式
        isHovering = false;           // 关闭悬浮状态
        m_baseSpeed = m_originalSpeed; // 恢复原始滚动速度
        m_slideSpeed = m_baseSpeed;    // 同步背景滚动速度
        startspeed = m_baseSpeed;      // 重置速度基准值
        isJumping = true;              // 允许跳跃状态
        jumpCount = maxJump;           // 重置跳跃次数
    });
     qApp->installEventFilter(this);  //对所有窗口和控件事件的全局拦截

}
// 音频系统
void MainWindow::setupAudioSystem()
{
    // 背景音乐播放器
    QAudioOutput* audioOutput = new QAudioOutput(this);//创建音频输出设备
    m_bgmPlayer = new QMediaPlayer(this);//创建媒体播放器对象
    m_bgmPlayer->setAudioOutput(audioOutput);//绑定音频输出设备
    audioOutput->setVolume(50);//设置音量
    m_bgmPlayer->setSource(QUrl("qrc:/bgm/build/游戏背景音乐0.mp3"));//​加载音频资源文件

    // 多音轨初始化
    for (int i = 0; i < 5; i++) {
        m_bgmPlayer1[i] = new QMediaPlayer(this);
        QAudioOutput* m_audioOutput = new QAudioOutput(this);
        m_audioOutput->setVolume(50);
        m_bgmPlayer1[i]->setAudioOutput(m_audioOutput);
        m_bgmPlayer1[i]->setSource(QUrl(m_bgmPaths[i]));
        m_bgmPlayer1[i]->setLoops(QMediaPlayer::Infinite);//循环播放
        QObject::connect(m_bgmPlayer1[i], &QMediaPlayer::mediaStatusChanged,
                         [this, i](QMediaPlayer::MediaStatus status){
                              if(status == QMediaPlayer::EndOfMedia){
                                  m_bgmPlayer1[i]->play(); // 音乐播完后重新播放
                              }
                        });

    }
    m_bgmPlayer->play();
    // 音效系统
    m_sfxPlayer = new QMediaPlayer(this);
    m_sfxPlayer->setAudioOutput(new QAudioOutput(this));
    m_sfxPlayer->setSource(QUrl("qrc:/bgm/build/撞.mp3"));

    m_powerupSfx = new QMediaPlayer(this);
    m_powerupSfx->setAudioOutput(new QAudioOutput(this));
    m_powerupSfx->setSource(QUrl("qrc:/bgm/build/道具.mp3"));

}




// 游戏对象管理
void MainWindow::updateGame()
{
    // 游戏状态检查：仅当游戏激活且玩家存在时执行更新
    if (!isGameActive || !player) return;

    // 更新背景音乐（根据当前背景组切换音乐轨道）
    updateBackgroundMusic();

    // 障碍物生成逻辑：每8秒生成新障碍物（通过QElapsedTimer计时）
    if (obstacleTimer.elapsed() > obstacle_interval) {
        generateObstacle();
        obstacleTimer.restart();  // 重置计时器
    }



    // 玩家跳跃物理模拟
    if(isJumping) {
        player->setY(player->y() + velocityY);  // 垂直位置更新
        velocityY += 0.8;  // 模拟重力加速度

        // 地面碰撞检测：当玩家Y坐标超过地面位置时复位
        qreal groundPosition = GROUND_Y - player->boundingRect().height();
        if(player->y() > groundPosition) {
            player->setY(groundPosition);
            isJumping = false;  // 结束跳跃状态
            velocityY = 0;      // 重置垂直速度
            jumpCount = 0;      // 重置跳跃次数
        }
    }


    foreach(Obstacle* o, obstacles) {
        o->setX(o->x() + startspeed);  // 向左移动障碍物
    }

    // 障碍物生命周期管理（使用可变迭代器）
    QMutableListIterator<Obstacle*> it(obstacles);
    while(it.hasNext()) {
        Obstacle* o = it.next();
        o->setX(o->x() + startspeed);  // 更新位置

        // 精确像素级碰撞检测（考虑图形透明度）
        if(player->collidesWithItem(o, Qt::IntersectsItemShape)) {
            if(hasShield) {  // 护盾状态处理
                hasShield = false;
                player->setOpacity(1.0);  // 恢复默认透明度
                player->setScale(1.0);   // 恢复原始大小
                scene->removeItem(o);    // 从场景移除障碍物
                it.remove();             // 从列表移除指针
                delete o;                // 释放内存
            } else {
                m_sfxPlayer->play();     // 播放碰撞音效
                gameOver();              // 触发游戏结束
                return;
            }
            break;  // 处理单个碰撞后跳出循环
        }

        // 移出屏幕左侧的障碍物清理
        if(o->x() < -o->boundingRect().width()) {
            scene->removeItem(o); // 从场景移除
            delete o; // 释放内存
            it.remove(); // 从列表移除指针
        }
    }

    // 金币处理逻辑
    QMutableListIterator<Coin*> cit(coins);
    while(cit.hasNext()) {
        Coin* c = cit.next();
        c->setX(c->x() + startspeed);  // 向左移动金币
        bool shouldRemove = false;

        // 金币收集检测
        if(c->collidesWithItem(player)) {
            score += 5;  // 得分计算
            scoreText->setPlainText(QString("得分: %1").arg(score));
            shouldRemove = true;
        }

        // 移出屏幕左侧检测
        if (c->x() + c->boundingRect().width() < 0) {
            shouldRemove = true;
        }

        // 移除已收集或移出屏幕的金币
        if (shouldRemove) {
            cit.remove();
            scene->removeItem(c);
            delete c;
        }
    }

    // 磁铁道具效果：吸引金币向玩家移动
    if(isMagnetActive) {
        foreach(Coin* c, coins) {
            if(c->x() > player->x()) {
                c->setX(c->x() - 8);  // X轴吸引速度
                // Y轴平滑过渡（差值系数0.1）
                c->setY(c->y() + (player->y()+20 - c->y())*0.1);
            }
        }
    }

    // 悬浮状态位置锁定
    if(isHovering) {
        player->setY(m_hoverYPosition);
    }

    // 道具移动逻辑
    foreach(PowerUp* p, powerUps) {
        p->setX(p->x() + startspeed);
    }

    // 道具碰撞检测与处理
    QMutableListIterator<PowerUp*> pit(powerUps);
    while(pit.hasNext()) {
        PowerUp* p = pit.next();
        p->setX(p->x() + startspeed);

        // 移出屏幕左侧的道具清理
        if (p->x() + p->boundingRect().width() < 0) {
            scene->removeItem(p);
            delete p;
            pit.remove();
            continue;
        }

        // 道具收集检测
        if(p->collidesWithItem(player)) {
            m_powerupSfx->play();            // 播放收集音效
            emit p->collected(p->getType()); // 触发道具效果信号
            pit.remove();
            scene->removeItem(p);
            delete p;
        }
    }

    // 护盾视觉效果处理
    if(hasShield) {
        player->setOpacity(0.7);  // 半透明效果
        player->setScale(1.2);   // 放大显示
    } else {
        player->setOpacity(1.0); // 恢复默认
        player->setScale(1.0);
    }
}
//动态背景组匹配机制
const MainWindow::BackgroundGroup* MainWindow::getCurrentGroup() const
{
    // 如果背景图元列表为空，返回第一个背景组（安全容错）
    if (m_slideItems.isEmpty()) return &bgGroups.first();

    // 计算视口中心点在场景坐标系中的X坐标
    qreal centerX = view->mapToScene(view->viewport()->rect().center()).x();

    // 遍历所有背景图元项
    foreach (QGraphicsPixmapItem* item, m_slideItems) {
        // 检测当前图元是否包含场景中心点
        if (item->x() <= centerX && (item->x() + item->pixmap().width()) > centerX) {
            // 从图元自定义数据中获取背景索引
            int bgIndex = item->data(0).toInt();

            // 遍历预定义的背景组配置
            for (auto &group : bgGroups) {
                // 匹配当前索引所在的分组范围
                if (bgIndex >= group.startIdx && bgIndex <= group.endIdx) {
                    return &group;  // 返回匹配的背景组指针
                }
            }
        }
    }
    // 默认返回第一个背景组（未匹配时的安全返回）
    return &bgGroups.first();
}


// 道具系统
void MainWindow::generatePowerUp()
{
    // 50%概率生成道具（0-99随机数 <50 时触发）
    if (QRandomGenerator::global()->bounded(100) < 50) {
        // 随机选择道具类型（0:护盾 1:磁铁 2:悬浮）
        PowerUp::Type type = static_cast<PowerUp::Type>(
            QRandomGenerator::global()->bounded(3));

        // 创建道具对象并设置初始位置（屏幕右侧，Y轴200-400随机位置）
        PowerUp* p = new PowerUp(type);
        p->setPos(view->width(), QRandomGenerator::global()->bounded(200, 400));

        // 连接道具收集信号与效果处理
        connect(p, &PowerUp::collected, [this](PowerUp::Type type) {
            handlePowerUpEffect(type);
        });

        // 将道具添加到场景和对象列表
        scene->addItem(p);       // 加入场景渲染
        powerUps.append(p);      // 加入道具管理列表
    }
}
//游戏道具管理机制
void MainWindow::handlePowerUpEffect(PowerUp::Type type)
{
    switch (type) {
    case PowerUp::Shield:
        hasShield = true;
        QTimer::singleShot(10000, [this]() { hasShield = false; });
        break;
    case PowerUp::Magnet:
        isMagnetActive = true;
        QTimer::singleShot(5000, [this]() { isMagnetActive = false; });
        break;
    case PowerUp::Hover:
        if (!isHovering) {
            isHovering = true;
            m_originalSpeed = m_baseSpeed;  // 保存原始速度
            m_baseSpeed = HOVER_SPEED;      // 设置悬浮速度
            m_slideSpeed = m_baseSpeed;      // 同步背景滚动速度
            startspeed = m_baseSpeed;       // 更新当前速度
            isJumping = false;              // 关闭跳跃状态
            velocityY = 0;                  // 重置垂直速度
            m_hoverYPosition = player->y(); // 记录悬停高度
            hoverTimer->start(6000);        // 启动6秒悬浮计时
        }
        break;
    }
}

// 其他关键功能实现
void MainWindow::startGameWithCharacter(int id)
{
    // 游戏初始化准备阶段
    cleanupGame();        // 清理上一局游戏资源
    pauseAllMusic();      // 暂停所有背景音乐
    resetSlidePosition(); // 重置背景滚动位置

    // 暂停主背景音乐（如果正在播放）
    if (m_bgmPlayer->playbackState() == QMediaPlayer::PlayingState) {
        m_bgmPlayer->pause();
        m_isMusicPaused = true;  // 记录音乐暂停状态
    }

    // 确保游戏窗口可见（处理可能的隐藏状态）
    if (!this->isVisible()) {
        this->show();  // 显示游戏窗口
        QApplication::processEvents();  // 立即处理UI事件
    }

    // 加载角色资源
    QString characterPath = QString(":/char%1.png").arg(id + 1);  // 构建角色路径
    QPixmap pixmap(characterPath);  // 加载角色图片

    // 资源加载失败处理
    if (pixmap.isNull()) {
        QMessageBox::critical(this, "错误", "角色图片加载失败！");
        return;  // 终止游戏启动
    }

    // 调整角色尺寸（缩放为原图的70%，保持宽高比）
    pixmap = pixmap.scaled(pixmap.width() * 0.7, pixmap.height() * 0.7,
                           Qt::KeepAspectRatio, Qt::SmoothTransformation);

    // 创建玩家图形项
    player = new QGraphicsPixmapItem(pixmap);
    // 设置初始位置：屏幕左侧8%处，地面高度 - 角色高度
    player->setPos(VIEW_WIDTH * 0.08, GROUND_Y - player->boundingRect().height());
    scene->addItem(player);  // 将玩家添加到场景

    // 初始化游戏状态
    obstacleTimer.start();   // 启动障碍物生成计时器
    player->setVisible(true);  // 显示玩家
    player->setFlag(QGraphicsItem::ItemIsFocusable);  // 允许接收焦点
    player->setFocus();       // 获取键盘焦点

    // 延迟启动游戏主系统（确保资源加载完成）
    QTimer::singleShot(200, [this]() {
        isGameActive = true;           // 激活游戏状态
        gameTimer->start(16);          // 启动游戏主循环（约60FPS）
        coinTimer->start(2500);        // 每2.5秒生成金币
        powerupTimer->start(3000);     // 每3秒生成道具
    });

    // 确保背景滚动系统启动
    QTimer::singleShot(100, [this](){
        if(!m_slideTimer->isActive()) {
            m_slideTimer->start(16);  // 启动背景滚动定时器
        }
    });
}

void MainWindow::cleanupGame()
{   // 恢复背景音乐
    if(m_isMusicPaused) {
        m_bgmPlayer->play();
        m_isMusicPaused = false;
    }

    // 重置游戏状态
    isGameActive = false;
    score = 0;
    startspeed = -3;
    obstacle_interval = 2000;

    // 清理游戏对象
    qDeleteAll(obstacles);
    qDeleteAll(coins);
    qDeleteAll(powerUps);
    obstacles.clear();
    coins.clear();
    powerUps.clear();

    // 重置玩家
    if (player) {
        scene->removeItem(player);
        delete player;
        player = nullptr;
    }
    if(returnBtn) {
        returnBtn->deleteLater();
        returnBtn = nullptr;
    }
    scoreText->setPlainText("得分: 0");
}

// 事件处理系统
void MainWindow::keyPressEvent(QKeyEvent* event)
{
    if (!isGameActive || !player || QApplication::focusWidget() != view || !scene->items().contains(player)) return;

    bool movementProcessed = false;

    if (isHovering) {
        handleHoverMovement(event);
        return;
    } else {
        switch (event->key()) {
        case Qt::Key_Up:
            if (jumpCount < maxJump) {
                jump();
                movementProcessed = true;
            }
            break;
        case Qt::Key_Left:{
            qreal newX = qMax(0.0, player->x() - 15.0);
            if (newX != player->x()) {
                player->setX(newX);
                movementProcessed = true;
            }

            break;}
        case Qt::Key_Right:{
            qreal rightBoundary = view->width() - player->boundingRect().width();
            qreal newX = qMin(rightBoundary, player->x() + 15.0);
            if (newX != player->x()) {
                player->setX(newX);
                movementProcessed = true;
            }
            break;
        }

        default:
            QMainWindow::keyPressEvent(event);
            return;
        }

    }

    if (movementProcessed) {
        player->update();
        scene->update(scene->itemsBoundingRect());
        view->viewport()->update();

    }
    event->accept();
}

void MainWindow::closeEvent(QCloseEvent* event)
{
    if (isGameActive) {
        QMessageBox::StandardButton reply = QMessageBox::question(
            this, "确认退出", "游戏正在进行中，确定要退出吗？",  QMessageBox::Yes | QMessageBox::No);

        if (reply == QMessageBox::No) {
            event->ignore();
            return;
        }
    }
    QMessageBox::information(this, "游戏结束", "谢谢游玩！");

    QMainWindow::closeEvent(event);
}

// 辅助功能
void MainWindow::updateBackgroundMusic()
{
    // 获取当前所处的背景组（根据场景滚动位置判断）
    const BackgroundGroup* group = getCurrentGroup();
    if (!group) return;  // 无效组检查

    // 根据背景组索引范围确定对应的音乐轨道
    int targetIndex = -1;
    if (group->startIdx >= 0 && group->endIdx <= 1) targetIndex = 0;   // 第1组背景 -> 音乐0
    else if (group->startIdx >= 2 && group->endIdx <= 3) targetIndex = 1; // 第2组 -> 音乐1
    else if (group->startIdx >= 4 && group->endIdx <= 5) targetIndex = 2; // 第3组 -> 音乐2
    else if (group->startIdx >= 6 && group->endIdx <= 7) targetIndex = 3; // 第4组 -> 音乐3
    else if (group->startIdx >= 8 && group->endIdx < 11) targetIndex = 4; // 第5组 -> 音乐4

    // 音乐切换逻辑（仅在需要更换时执行）
    if (targetIndex != m_currentMusicIndex) {
        // 停止当前播放的音乐（如果有）
        if (m_currentMusicIndex >= 0) {
            m_bgmPlayer1[m_currentMusicIndex]->pause();
        }

        // 播放新音乐（有效索引时）
        if (targetIndex >= 0) {
            m_bgmPlayer1[targetIndex]->play();      // 启动新音轨
            m_currentMusicIndex = targetIndex;      // 更新当前音乐索引
        }
    }
}
void MainWindow::handleHoverMovement(QKeyEvent* event)
{
    const qreal moveSpeed = 15.0;
    const qreal topBoundary = VIEW_HEIGHT * 0.3;
    const qreal bottomBoundary = GROUND_Y - player->boundingRect().height() - 50;

    switch(event->key()) {
    case Qt::Key_Up:
        player->setY(qMax(player->y() - moveSpeed, topBoundary));
        m_hoverYPosition = player->y();
        break;
    case Qt::Key_Down:
        player->setY(qMin(player->y() + moveSpeed, bottomBoundary));
        m_hoverYPosition = player->y();
        break;
    }
}

// 金币生成（支持多种排列模式）
void MainWindow::generateCoin()
{
    const BackgroundGroup* group = getCurrentGroup();
    if (!group) return;

    // 加载对应背景组的金币皮肤[6,7](@ref)
    QString coinPath = QString(":/coin%1.png").arg(group->coinImg);

    // 随机选择生成模式（水平线/圆弧/波浪）
    enum Pattern { Horizontal, Arc, Wave };
    Pattern pattern = static_cast<Pattern>(QRandomGenerator::global()->bounded(3));

    // 公共参数设置
    const int baseX = view->width(); // 初始生成在屏幕右侧外
    const int baseY = QRandomGenerator::global()->bounded(200, 400);

    switch(pattern) {
    case Horizontal: // 水平排列（3-5个）
    {
        int count = QRandomGenerator::global()->bounded(3, 6);
        const int spacing = 80;
        for(int i = 0; i < count; ++i) {
            Coin* coin = new Coin(coinPath);
            coin->setPos(baseX + i * spacing, baseY);
            scene->addItem(coin);
            coins.append(coin);
        }
        break;
    }
    case Arc: // 圆弧排列（5个半圆）
    {
        const int radius = 100;
        for(int i = 0; i < 5; ++i) {
            Coin* coin = new Coin(coinPath);
            double angle = M_PI * i / 6; // 0~150度
            coin->setPos(
                baseX + radius * cos(angle),
                baseY - radius * sin(angle)
                );
            scene->addItem(coin);
            coins.append(coin);
        }
        break;
    }
    case Wave: // 波浪形排列（7个）
    {
        const int amplitude = 60;
        const int waveCount = 2;
        for(int i = 0; i < 7; ++i) {
            Coin* coin = new Coin(coinPath);
            double phase = 2 * M_PI * waveCount * i / 6;
            coin->setPos(
                baseX + i * 80,
                baseY + amplitude * sin(phase)
                );
            scene->addItem(coin);
            coins.append(coin);
        }
        break;
    }
    default: {
        Coin* coin = new Coin(coinPath);
        coin->setPos(baseX, baseY);
        scene->addItem(coin);
        coins.append(coin);
        break;
    }}
}

// 背景轮播
void MainWindow::updateSlides()
{
    // 仅在游戏激活状态下执行背景滚动
    if(!isGameActive) return;

    // 遍历所有背景图元项
    foreach(QGraphicsPixmapItem* item, m_slideItems) {
        // 水平移动：根据滚动速度更新X坐标（负值向左滚动）
        item->setX(item->x() + m_slideSpeed);

        // 获取当前图元尺寸并计算垂直居中位置
        QPixmap currentPixmap = item->pixmap();
        qreal newY = (VIEW_HEIGHT - currentPixmap.height()) / 2;

        // 保持图元垂直居中显示
        item->setY(newY);
    }

    // 获取列表首位的背景图元（最左侧的图元）
    QGraphicsPixmapItem* firstItem = m_slideItems.first();

    // 检测首图元是否完全移出屏幕左侧
    if (firstItem->x() + firstItem->pixmap().width() < 0) {
        // 获取列表末尾的图元（当前最右侧的图元）
        QGraphicsPixmapItem* lastItem = m_slideItems.last();

        // 计算新位置：紧接最后一个图元的右侧
        qreal newX = lastItem->x() + lastItem->pixmap().width();

        // 重新计算垂直居中坐标
        qreal posY = (VIEW_HEIGHT - firstItem->pixmap().height()) / 2;

        // 将移出屏幕的图元移动到队列末端
        firstItem->setPos(newX, posY);  // 设置新位置

        // 更新图元列表顺序
        m_slideItems.removeFirst();    // 从列表头部移除
        m_slideItems.append(firstItem); // 添加到列表尾部
    }
}

// 障碍物生成
void MainWindow::generateObstacle() {
    const BackgroundGroup* group = getCurrentGroup();
    if (!group) return;

    // 动态加载障碍物图片
    QString path = QString(":/obstacle%1.png").arg(group->obstacleImg);
    Obstacle* o = new Obstacle(path); // 假设Obstacle构造函数接受路径
    qreal obstacleY = GROUND_Y - o->boundingRect().height();
    o->setPos(VIEW_WIDTH, obstacleY);
    scene->addItem(o);
    obstacles.append(o);
}


// 道具处理
void MainWindow::handlePowerUps()
{
    QMutableListIterator<PowerUp*> it(powerUps);
    while (it.hasNext()) {
        PowerUp* p = it.next();
        p->setX(p->x() + startspeed);
        if (p->x() < -p->boundingRect().width()) {
            scene->removeItem(p);
            delete p;
            it.remove();
        }
    }
}

// 获取当前背景组

// 游戏结束
void MainWindow::gameOver()
{   pauseAllMusic();
    gameTimer->stop();
    coinTimer->stop();
    powerupTimer->stop();
    isGameActive = false;
    QMessageBox::information(this, "游戏结束", QString("得分: %1").arg(score));
    cleanupGame();
    emit returnToMainMenu();
}

// 暂停音乐
void MainWindow::pauseAllMusic()
{
    for (int i = 0; i < 5; ++i) {
        if (m_bgmPlayer1[i]->playbackState() == QMediaPlayer::PlayingState) {
            m_bgmPlayer1[i]->pause();
        }
    }
     m_currentMusicIndex = -1;
}

// 重置背景位置
void MainWindow::resetSlidePosition()
{
    for(int i = 0; i < m_slideItems.size(); ++i) {
        QGraphicsPixmapItem* item = m_slideItems[i];
        QPixmap pixmap = item->pixmap();
        qreal yPos = (VIEW_HEIGHT - pixmap.height())/2;
        item->setPos(i * MainWindow::VIEW_WIDTH, yPos);
    }

    std::sort(m_slideItems.begin(), m_slideItems.end(),
              [](QGraphicsPixmapItem* a, QGraphicsPixmapItem* b) {
                  return a->x() < b->x();
              });

    if(m_slideTimer->isActive()) m_slideTimer->stop();
    m_slideTimer->start(16);

}

// 跳跃功能
void MainWindow::jump()
{
    if(jumpCount < maxJump) {
        isJumping = true;
        velocityY = (jumpCount == 0) ? firstJumpForce : secondJumpForce;
        jumpCount++;
    }

}

// 角色选择对话框（带资源验证）
void MainWindow::showCharacterDialog()
{
    CharacterSelectDialog dialog(this);

    if (dialog.exec() == QDialog::Accepted) {//显示模态对话框并等待用户操作
        int selectedId = dialog.selectedId();
        if (selectedId != -1) {
            startBtn->hide();    // 隐藏开始按钮
            startGameWithCharacter(selectedId); // 启动游戏
        }
    }

}

// 保持视图焦点
void MainWindow::ensureViewFocus()
{
    if (view && view->isVisible()) {
        view->setFocus();
    }
}

// 事件过滤器
bool MainWindow::eventFilter(QObject* watched, QEvent* event)
{
    if (watched == view && event->type() == QEvent::KeyPress) {
        QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
        forwardKeyEvent(keyEvent);
        return true;
    }
    return QMainWindow::eventFilter(watched, event);
}

void MainWindow::forwardKeyEvent(QKeyEvent* event)
{
    // 直接调用按键处理逻辑
    keyPressEvent(event);
}
